sHelp
                                     GL.ALLOC
     i   2
   gl.alloc.log.file
     gl.alloc.log.errors
     gl.alloc.log.presets
     gl.alloc.log.previews
       gl.alloc.log.preview.amounts
     gl.alloc.log.tables
   gl.allocation.tables.file
     gl.allocation.rules
       gl.allocation.base.ranges
       gl.base.account.combinations
       gl.allocation.budget.sum
         gl.allocation.budget.stats
       gl.allocation.charge.accounts
       gl.allocation.stats.compvals
     gl.allocation.table.users

 Ì     i   2
gl.alloc.log.file    (log) 
[log.num]
*LXL[lxLN]

 Field Name                 Len Dat Typ  J  DPM            Offset/Local/VAL                                        
 log.num                      6 PINT     R                 lxLN                                                        
 log.alloc.date               8 DATE     L                 *LXL[lxLN]B|3                                               
 log.batch.date               8 DATE     L                 VAL=IF{@log.batch.urn @GL.BATCH.date[@log.batch.urn]}       
 log.batch.number             3 PINT     R                 VAL=IF{@log.batch.urn @GL.BATCH.number[@log.batch.urn]      
                                                           VAL=}                                                       
 log.batch.status            10 FREE     L                 VAL=IF{@log.batch.urn @GL.BATCH.status[@log.batch.urn]      
                                                           VAL=}                                                       
 log.batch.urn                6 PINT     R                 *LXL[lxLN]A|2                                               
 log.budget                   8 FREE     L  GL.BUDGET      *LXL[lxLN]B|0                                           
 log.error                    1 YN       L                 VAL=IF{+@log.errors[log.num,""] "Y"}                        
 log.error.yn                 1 YN       L                 VAL=IF{+@log.errors[log.num,""] "Y";"N"}                    
 log.fy                       4 PINT     R                 *LXL[lxLN]B|1                                               
 log.journal                 10 FREE     L  MIS.GL.JOURNAL *LXL[lxLN]A|0                                           
 log.method                  12 CHOICE   L                 *LXL[lxLN]|2                                                
 log.on.index                 1 YN       L                 VAL=IF{@log.batch.urn IF{%GL.BATCH.alloc.x(@log.batch.      
                                                           VAL=urn) "Y"}}                                              
 log.period                  10 FREE     L  MIS.GL.PERIOD  *LXL[lxLN]A|1                                           
 log.preset                   1 YN       L                 *LXL[lxLN]B|2                                               
 log.save                     1 YN       L                 *LXL[lxLN]|8                                                
 log.save.yn                  1 YN       L                 VAL=IF{@log.save="Y";"N"}                                   
 log.stage.desc              30 FREE     L                 *LXL[lxLN]S                                                 
 log.start.date               8 DATE     L                 *LXL[lxLN]|3                                                
 log.start.time               4 TIME     L                 *LXL[lxLN]|4                                                
 log.status                   9 CHOICE   L                 *LXL[lxLN]|1                                                
 log.stop.date                8 DATE     L                 *LXL[lxLN]|5                                                
 log.stop.time                4 TIME     L                 *LXL[lxLN]|6                                                
 log.type                     2 CHOICE   L                 *LXL[lxLN]|0                                                
 log.user                    10 FREE     L  MIS.USER       *LXL[lxLN]|7                                            
 Ì      i   2
gl.alloc.log.errors    (log.errors) 
[log.num, log.err.num]
*LXL[lxLN]E[lxEL]

 Field Name                 Len Dat Typ  J  DPM            Offset/Local/VAL                                        
 log.err.num                  3 PINT     R                 lxEL                                                        
 log.err.line                92 FREE     L                 *LXL[lxLN]E[lxEL]                                           
 Ì      i   2
gl.alloc.log.presets    (log.preset.to.zero) 
[log.num, log.preset.acct]
*LXL[lxLN]Z[ga]

 Field Name                 Len Dat Typ  J  DPM            Offset/Local/VAL                                        
 log.preset.acct             25 FREE     L  MIS.GL.ACCOUNT ga                                                      
 Ì      i   2
gl.alloc.log.previews    (log.previews) 
[log.num, log.pr.acct]
*LXL[lxLN]P[ga]

 Field Name                 Len Dat Typ  J  DPM            Offset/Local/VAL                                        
 log.pr.acct                 25 FREE     L  MIS.GL.ACCOUNT ga                                                      
 log.pr.tot.amt              12 SDEC     R                 *LXL[lxLN]P[ga]|0                                           
 Ì      i   2
gl.alloc.log.preview.amounts    (log.preview.amts) 
[log.num,log.pr.acct, log.pr.queue,log.pr.rule]
*LXL[lxLN]P[ga]A[lxQ,lxR]

 Field Name                 Len Dat Typ  J  DPM            Offset/Local/VAL                                        
 log.pr.queue                 2 PINT     R                 lxQ                                                         
 log.pr.rule                  5 PDEC     R                 lxR                                                         
 log.pr.after                12 SDEC2    R                 VAL=(@GL.ALLOC.log.pr.before+@GL.ALLOC.log.pr.amt)          
 log.pr.amt                  12 SDEC2    R                 *LXL[lxLN]P[ga]A[lxQ,lxR]|1                                 
 log.pr.before               12 SDEC2    R                 *LXL[lxLN]P[ga]A[lxQ,lxR]|0                                 
 Ì      i   2
gl.alloc.log.tables    (log.tables) 
[log.num, log.queue]
*LXL[lxLN]T[lxQ]

 Field Name                 Len Dat Typ  J  DPM            Offset/Local/VAL                                        
 log.queue                    2 PINT     R                 lxQ                                                         
 log.table                    8 FREE     L  GL.ALLOC       *LXL[lxLN]T[lxQ]                                        
 Ì     i   2
gl.allocation.tables.file    (main) 
[id]
*LX[lx]

 Field Name                 Len Dat Typ  J  DPM            Offset/Local/VAL                                        
 id                           8 FREE     L                 lx                                                          
 description                 30 FREE     L                 *LX[lx]|0                                                   
 method                      12 CHOICE   L                 *LX[lx]|2                                                   
 priority                     2 PINT     R                 *LX[lx]|1                                                   
 Ì      i   2
gl.allocation.rules    (rules) 
[id, rule.num]
*LX[lx]R[lxR]

 Field Name                 Len Dat Typ  J  DPM            Offset/Local/VAL                                        
 rule.num                     5 PDEC     R                 lxR                                                         
 class                        2 PINT     R  MIS.GL.CLASS   *LX[lx]R[lxR]S                                          
 clearing.account            25 FREE     L  MIS.GL.ACCOUNT *LX[lx]R[lxR]|1                                         
 comb.range                   1 CHOICE   L                 *LX[lx]R[lxR]|3                                             
 rule.description            20 FREE     L                 *LX[lx]R[lxR]|0                                             
 st.class                     2 PINT     R  MIS.GL.CLASS   *LX[lx]R[lxR]D|0                                        
 st.from.chg1                 3 FREE     L  MIS.GL.COMP    *LX[lx]R[lxR]D|1                                        
 st.from.chg2                 3 FREE     L  MIS.GL.COMP    *LX[lx]R[lxR]D|2                                        
 st.from.chg3                 3 FREE     L  MIS.GL.COMP    *LX[lx]R[lxR]D|3                                        
 statistic.sum               12 PDEC     R                 *LX[lx]R[lxR]|2                                             
 Ì      i   2
gl.allocation.base.ranges    (base.account.range) 
[id,rule.num, account.from]
*LX[lx]R[lxR]R[gaF]

 Field Name                 Len Dat Typ  J  DPM            Offset/Local/VAL                                        
 account.from                25 FREE     L  MIS.GL.ACCOUNT gaF                                                     
 account.thru                25 FREE     L  MIS.GL.ACCOUNT *LX[lx]R[lxR]R[gaF]                                     
 Ì      i   2
gl.base.account.combinations    (component.selections) 
[id,rule.num, num]
*LX[lx]R[lxR]S[mQ]

 Field Name                 Len Dat Typ  J  DPM            Offset/Local/VAL                                        
 num                          2 PINT     R                 mQ                                                          
 bottom.comp                  3 FREE     L  MIS.GL.COMP    *LX[lx]R[lxR]S[mQ]|1                                    
 comp                         3 FREE     L  MIS.GL.COMP    *LX[lx]R[lxR]S[mQ]|0                                    
 values                      45 FREE     L                 *LX[lx]R[lxR]S[mQ]|2                                        
 Ì      i   2
gl.allocation.budget.sum    (budgets) 
[id,rule.num, budget]
*LX[lx]R[lxR]B[lwW]

 Field Name                 Len Dat Typ  J  DPM            Offset/Local/VAL                                        
 budget                       8 FREE     L  GL.BUDGET      lwW                                                     
 budget.sum                  12 INT      R                 *LX[lx]R[lxR]B[lwW]|0                                       
 Ì      i   2
gl.allocation.budget.stats    (budget.stats) 
[id,rule.num,budget, budget.acct]
*LX[lx]R[lxR]B[lwW]C[ga]

 Field Name                 Len Dat Typ  J  DPM            Offset/Local/VAL                                        
 budget.acct                 25 FREE     L                 ga                                                          
 budget.stat                 10 INT      R                 *LX[lx]R[lxR]B[lwW]C[ga]|0                                  
 Ì      i   2
gl.allocation.charge.accounts    (charge.accounts) 
[id,rule.num, charge.account]
*LX[lx]R[lxR]C[ga]

 Field Name                 Len Dat Typ  J  DPM            Offset/Local/VAL                                        
 charge.account              25 FREE     L  MIS.GL.ACCOUNT ga                                                      
 statistic                   10 INT      R                 *LX[lx]R[lxR]C[ga]|0                                        
 Ì      i   2
gl.allocation.stats.compvals    (stats.sel) 
[id,rule.num, st.num]
*LX[lx]R[lxR]D["S",mQ]

 Field Name                 Len Dat Typ  J  DPM            Offset/Local/VAL                                        
 st.num                       2 PINT     R                 mQ                                                          
 st.bottom.comp               3 FREE     L  MIS.GL.COMP    *LX[lx]R[lxR]D["S",mQ]|1                                
 st.comp                      3 FREE     L  MIS.GL.COMP    *LX[lx]R[lxR]D["S",mQ]|0                                
 st.values                   45 FREE     L                 *LX[lx]R[lxR]D["S",mQ]|2                                    
 Ì      i   2
gl.allocation.table.users    (users) 
[id, user]
*LX[lx]U[gu]

 Field Name                 Len Dat Typ  J  DPM            Offset/Local/VAL                                        
 user                        10 FREE     L  MIS.USER       gu                                                      
 Ì       2
 INDEX FILE/INTERNAL NAME           SUBSCRIPTS/PHYSICAL BASE

 gl.alloc.log.x                     [log.type,log.num]
   log.x                              ?LXLX[lxLT,lxLN]